// #include <iostream>
// #include <stdio.h>
// #include <string.h>
// #include <unistd.h>
// #include <sys/wait.h>
// #include<thread>
// #include<mutex>
// #define ww 1
// #define ww1 (1 << 1)
// #define ww2 (1 << 2)
// #define ww3 (1 << 3)
// #define ww4 (1 << 4)

// std::mutex dd;


// void func(int mid)
// {
//     if (mid & ww)
//         std::cout << 1 << std::endl;
//     if (mid & ww1)
//         std::cout << 2 << std::endl;
//     if (mid & ww2)
//         std::cout << 3 << std::endl;
//     if (mid & ww3)
//         std::cout << 4 << std::endl;
//     if (mid & ww4)
//         std::cout << 5 << std::endl;
// }
// void print_dd(int e,char c){
//     std::unique_lock<std::mutex> hh(dd);
//     for(int i=0;i<e;i++){
//         std::cout<<c<<" ";
//     }
//     std::cout<<std::endl;
// }


// int main()
// {

//     // func(1);
//     // std::cout<<std::endl;
//     // func(ww|ww2);
//     // std::cout<<std::endl;
//     // func(ww1|ww2);
//     // std::cout<<std::endl;
//     // func(ww3|ww4);
//     // std::cout<<std::endl;

//     // FILE * f1 = fopen("./log.txt","a");
//     // std::string z = "z\n";
//     // fputs(z.c_str(),f1);
//     // delete(f1);
//     // FILE * f2= fopen("./log.txt","r");
//     // char buffer[13];
//     // fgets(buffer,13,f1);
//     // buffer[12]='\0';
//     // std::cout<<buffer<<std::endl;
//     // delete(f2);
//     // return 0;

//     // 在进度条里面\r相当于是起到了一个将缓存区的内容进行重头开始的定位，使得可以将数据从头开始刷新，而不是从尾部开始刷新

//     // for(int i=0;i<100;i++){
//     //     std::cout<<"\r";
//     //     for(int j=0;j<i;j++){
//     //         std::cout<<"$";
//     //     }
//     //     // std::cout<<std::endl;
//     //     std::cout.flush();
//     //     sleep(1);
//     // }
//     // return 0;

//     // for (int i = 0; i < 100; i++)
//     // {
//     //     char *s1 = "123456\n";
//     //     write(1, s1, strlen(s1));
//     //     char *s2 = "789456123\n";
//     //     fprintf(stdout, "%s", s2);
//     //     char *s3 = "8520963741\n";
//     //     fwrite(s3, strlen(s3), 1, stdout);
//     //     sleep(1);
//     // }

//     //  pid_t pid1 = fork();  // 创建第一个子进程

//     // if (pid1 < 0) {
//     //     // fork 失败
//     //     perror("Fork failed");
//     //     return 1;
//     // } else if (pid1 == 0) {
//     //     // 第一个子进程
//     //     printf("I am the first child process with PID: %d ppid = %d\n", getpid(),getppid());

//     //     pid_t pid2 = fork();  // 创建第二个子进程 (子进程的子进程)

//     //     if (pid2 < 0) {
//     //         perror("Fork failed");
//     //         return 1;
//     //     } else if (pid2 == 0) {
//     //         // 第二个子进程
//     //         printf("I am the son child process with PID: %d,ppid=%d\n", getpid(),getppid());
//     //     }

//     //     // 父进程继续
//     //     sleep(1);  // 让子进程有时间运行
//     // } else {
//     //     // 原父进程
//     //     pid_t pid3 = fork();
//     //     if(pid3==0){
//     //         printf("I am the second child process with PID: %d,ppid=%d\n", getpid(),getppid());
//     //     }else{
//     //         printf("I am the parent process with PID: %d,ppid = %d\n", getpid(),getppid());
//     //     }
//     // }

//     // pid_t pid1 = fork();
//     // if (pid1 == 0)
//     // {
//     //     // 第一个子进程
//     //     printf("Child 1 (PID: %d) is running (pPID: %d)\n", getpid(), getppid());
//     //     sleep(1); // 模拟工作
//     // }
//     // else
//     // {
//     //     pid_t pid2 = fork();
//     //     if (pid2 == 0)
//     //     {
//     //         // 第二个子进程
//     //         printf("Child 2 (PID: %d) is running (pPID: %d)\n", getpid(), getppid());
//     //         sleep(2); // 模拟工作
//     //     }
//     // }
//     // // 等待所有子进程结束
//     // int status;
//     // pid_t child_pid;
//     // while ((child_pid = wait(&status)) > 0)
//     // {
//     //     std::cout << "Child process " << child_pid << " has terminated." << std::endl;
//     // }
//     // // 父进程
//     // printf("Parent (PID: %d) is waiting for children\n", getpid());

//     // printf("All children have terminated\n");

//     // return 0;

//     // pid_t pid;
//     // int count = 0;
//     // pid = fork(); // fork一个进程
//     // if (pid == 0)
//     // {                                                           // pid为0,
//     //     printf("this is child process, pid is %d\n", getpid()); // getpid返回的是当前进程的PID
//     //     count += 2;
//     //     printf("count = %d\n", count);
//     // }
//     // else if (pid > 0)
//     // {
//     //     printf("this is father process, pid is %d\n", getpid());
//     //     count++;
//     //     printf("count = %d\n", count);
//     // }
//     // else
//     // {
//     //     fprintf(stderr, "ERROR:fork() failed!\n");
//     // }

//     // while(1){
//     //     std::cout<<"1 2"<<std::endl;
//     //     sleep(3);
//     // }

//     /***********下面是阻塞状态的进程等待************************* */
//     // pid_t pid = fork(); // 创建子进程

//     // if (pid < 0)
//     // {
//     //     // fork失败
//     //     perror("fork failed");
//     //     exit(1);
//     // }
//     // else if (pid == 0)
//     // {
//     //     // 子进程
//     //     // 模拟正常退出
//     //     exit(42); // 退出码可以是一个任意数值
//     // }
//     // else
//     // {
//     //     // 父进程
//     //     int status;
//     //     // pid_t wpid = waitpid(pid, &status, 0); // 等待子进程结束
//     //      pid_t wpid = waitpid(pid, &status,WNOHANG); // 等待子进程结束

//     //     if (wpid == -1)
//     //     {
//     //         // waitpid失败
//     //         perror("waitpid failed");
//     //         exit(1);
//     //     }

//     //     // 检查退出状态
//     //     if (WIFEXITED(status))
//     //     {
//     //         int exit_code = WEXITSTATUS(status); // 获取退出码
//     //         printf("1子进程正常退出，退出码: %d\n", exit_code);
//     //         int term_signal = WTERMSIG(status); // 获取终止信号
//     //         printf("子进程被信号终止，信号编号: %d\n", term_signal);
//     //     }
//     //     else if (WIFSIGNALED(status))
//     //     {
//     //         int exit_code = WEXITSTATUS(status); // 获取退出码
//     //         printf("2子进程正常退出，退出码: %d\n", exit_code);
//     //         int term_signal = WTERMSIG(status); // 获取终止信号
//     //         printf("子进程被信号终止，信号编号: %d\n", term_signal);
//     //     }
//     //     else
//     //     {
//     //         printf("子进程未正常退出\n");
//     //     }
//     // }

//     /*****************下面是非阻塞状态下的 等待************************* */
//     // pid_t pid = fork(); // 创建子进程

//     // if (pid < 0)
//     // {
//     //     // fork失败
//     //     perror("fork failed");
//     //     exit(1);
//     // }
//     // else if (pid == 0)
//     // {
//     //     for(int i=0;i<10;i++){
//     //         sleep(2);
//     //     }
//     //     // 子进程
//     //     // 模拟正常退出
//     //     exit(42); // 退出码可以是一个任意数值
//     // }
//     // else
//     // {
//     //     // 父进程
//     //     int status;
//     //     bool running = true;

//     //     while (running)
//     //     {
//     //         pid_t wpid = waitpid(pid, &status, WNOHANG); // 非阻塞等待

//     //         if (wpid == -1)
//     //         {
//     //             // waitpid失败
//     //             perror("waitpid failed");
//     //             exit(1);
//     //         }
//     //         else if (wpid == 0)
//     //         {
//     //             // 子进程还在运行
//     //             printf("子进程仍在运行...\n");
//     //             sleep(1); // 避免 CPU 忙等
//     //         }
//     //         else
//     //         {
//     //             // 子进程已结束
//     //             running = false;
//     //             if (WIFEXITED(status))
//     //             {
//     //                 int exit_code = WEXITSTATUS(status); // 获取退出码
//     //                 printf("子进程正常退出，退出码: %d\n", exit_code);
//     //             }
//     //             else if (WIFSIGNALED(status))
//     //             {
//     //                 int term_signal = WTERMSIG(status); // 获取终止信号
//     //                 printf("子进程被信号终止，信号编号: %d\n", term_signal);
//     //             }
//     //             else
//     //             {
//     //                 printf("子进程未正常退出\n");
//     //             }
//     //         }
//     //     }
//     // }

//     ///////////////模拟进程被替换////////////////////////////

//     // pid_t pid = fork(); // 创建子进程

//     // if (pid < 0) {
//     //     // fork失败
//     //     perror("fork failed");
//     //     return 1;
//     // } else if (pid == 0) {
//     //     // 子进程
//     //     // 使用 execv 执行 "ls" 命令
//     //     char *argv[] = {"ls", "-l", NULL}; // 参数列表，必须以 NULL 结尾
//     //     execv("/bin/ls", argv);

//     //     // 如果 execv 返回，说明出错
//     //     perror("execv failed");
//     //     exit(1);
//     // } else {
//     //     // 父进程
//     //     // 等待子进程完成
//     //     wait(NULL);
//     //     printf("子进程已完成\n");
//     // }
//     // return 0;

//     //************使用类似于自定义的敏林行的效果***************** */
//     // 设置自定义环境变量
//     // setenv("MY_COMMAND", "ls", 1);
//     // setenv("MY_OPTION", "-l", 1);

//     // // Fork 创建子进程
//     // pid_t pid = fork();

//     // if (pid < 0) {
//     //     perror("fork failed");
//     //     exit(1);
//     // } else if (pid == 0) {
//     //     // 在子进程中读取环境变量
//     //     const char *command = getenv("MY_COMMAND");
//     //     const char *option = getenv("MY_OPTION");
        
//     //     if (command != NULL) {
//     //         // 使用 exec 执行环境变量中的命令
//     //         execlp(command, command, option, NULL);
//     //         // 如果 exec 成功，下面的代码不会执行
//     //         perror("exec failed");
//     //         exit(2);
//     //     } else {
//     //         fprintf(stderr, "Command not found in environment.\n");
//     //         exit(3);
//     //     }
//     // } else {
//     //     // 父进程
//     //     wait(NULL);  // 等待子进程结束
//     //     printf("Child process completed.\n");
//     // }



//     std::thread t1(print_dd,4,'5');
//     std::thread t2(print_dd,6,'8');
//     t1.join();
//     t2.join();
//     return 0;
// }




//********************用c++的方式进行线程池此创建************************* */
#include <iostream>
#include <thread>              // 包含线程库
#include <vector>             // 向量库
#include <queue>              // 队列库
#include <mutex>              // 互斥锁库
#include <condition_variable> // 条件变量库
#include <functional>         // 函数对象库
#include <atomic>            // 原子变量库
#include<unistd.h>
// 线程池类
class ThreadPool {
public:
    // 构造函数
    ThreadPool(size_t threadCount) : stop(false) {
        for (size_t i = 0; i < threadCount; ++i) {
            // 创建并启动线程
            workers.emplace_back(std::thread(&ThreadPool::workerThread, this));
        }
    }

    // 析构函数
    ~ThreadPool() {
        {
            // 锁住互斥量
            std::unique_lock<std::mutex> lock(mutex);
            stop = true; // 设置停止标志
        }
        cv.notify_all(); // 唤醒所有工作线程
        for (std::thread &worker : workers) {
            worker.join(); // 等待每个线程完成
        }
    }

    // 提交任务
    template <class F>
    void enqueue(F&& f) {
        {
            // 锁住互斥量
            std::unique_lock<std::mutex> lock(mutex);
            tasks.emplace(std::forward<F>(f)); // 将任务添加到队列
        }
        cv.notify_one(); // 唤醒一个工作线程
    }

private:
    // 工作线程函数
    void workerThread() {
        while (true) {
            std::function<void()> task; // 定义任务

            {
                // 锁住互斥量
                std::unique_lock<std::mutex> lock(mutex);
                cv.wait(lock, std::bind(&ThreadPool::conditionCheck, this)); // 等待条件
                if (stop && tasks.empty()) return; // 如果停止并且没有任务，则退出

                task = std::move(tasks.front()); // 获取任务
                tasks.pop(); // 从队列中移除任务
                sleep(1);
            }
            task(); // 执行任务
            
        }
    }

    // 条件检查函数
    bool conditionCheck() {
        return stop || !tasks.empty(); // 检查停止标志或任务队列是否非空
    }

    std::vector<std::thread> workers; // 线程集合
    std::queue<std::function<void()>> tasks; // 任务队列
    std::mutex mutex; // 互斥量
    std::condition_variable cv; // 条件变量
    bool stop; // 停止标志
};

// 示例任务类
//下面是通过对于()的重载使得对于外界来说只要变量后面加上（）就是对于任务函数的调用，这个会使得程序在访问的时候方便很多。
class ExampleTask {
public:
    // 执行任务的函数
    void operator()() {
        std::cout << "Task is running in thread: " << std::this_thread::get_id() << std::endl;
    }
};
class Example {
public:
    // 执行任务的函数
    void operator()() {
        std::cout << "Task is running in thread: " << std::this_thread::get_id() << std::endl;
        std::cout << "Task is running in thread: " << getppid() << std::endl;
    }
};

int main() {
    ThreadPool pool(4); // 创建一个包含4个线程的线程池

    for (int i = 0; i < 10; ++i) {
        ExampleTask task; // 创建任务对象
        Example task1;
        pool.enqueue(task); // 将任务传递给线程池
        pool.enqueue(task1);
    }

    // std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待任务完成

    return 0; // 程序结束
}